The present invention relates to the field of software development and, more particularly, to synchronizing development code and deployed executable versioning within distributed systems.
A common problem within distributed systems can be the inability to easily identify which artifact versions correspond to each other between development and runtime environments. That is, the relationship between a version of source code in development and the deployed executable (e.g., runtime executable) can be unknown. This can result in synchronization problems during development and deployment. One such problem can include source code overwriting incorrect versions of the executable within a runtime environment (e.g., production system) after deployment.
In one scenario, developer A can work in a development environment performing changes to source code that was deployed to a runtime environment while developer B can also enact different changes to the same code. Either developer can deploy the updated code with his/her changes at any time. Before deploying any changes, he/she may want to know which version of code is currently running and to ensure whether it is based off of the same version of code being deployed.
Currently there is no viable solution for a developer to retrieve such information that can be used to help manage different versions of source code being developed and deployed. Therefore, if developer B has already deployed his/her changes first, developer A can potentially overwrite developer B's changes.
The problem can be exacerbated when the source code corresponding to the deployed executable cannot be identified nor located. This can occur when a developer performs changes to source code which is deployed to a runtime system and does not make the source code available. Further, when the currently running version of a product requires changes, it can be difficult to determine which version of the source code is associated with the running version of the product. Additionally, obtaining the appropriate version of the source code can be difficult when the source code developer is not available.
Known solutions which are currently employed include requiring developers to manually contact each other to determine which version of the executing product is associated with a version of the source code. One drawback to this approach is the time delay that can occur between developer interactions. For example, when a developer is temporarily unavailable for contact, determining corresponding source code versions to a product can be delayed.
Another approach includes developers manually comparing source code in a development environment with executables in a runtime environment. In some instances of this approach, source code must be compared against multiple executables in multiple runtime environments. This approach also suffers from high levels of complexity, considerable temporal delays, and is error-prone. For example, a developer is required to compare all files of all types (e.g., text, binary, etc.), traverse through directory structures, and use appropriate criteria (e.g., size, content, timestamp, etc.) to determine a corresponding source code version for a runtime executable. In many instances, deployed systems can vary significantly from development systems disallowing automation of this process.